package cn.biplam.common.wrapper.sqlresult;

import java.io.Serializable;
import java.sql.ResultSet;
import java.util.Map;

import cn.biplam.common.client.DataFilter;
import cn.biplam.common.client.DbResource;
import cn.biplam.common.tools.TOOLS;
import cn.biplam.common.wrapper.D2Array;
import cn.biplam.common.wrapper.ErrorMessage;
import cn.biplam.common.wrapper.KvMap;
import cn.biplam.common.wrapper.Result;
import cn.biplam.common.wrapper.sqlresult.SqlResultMetaData.Sql_Result_Column_Opt_Flag;
import cn.biplam.common.wrapper.sqlresult.SqlResultMetaData.Sql_Result_Row_Opt_Flag;

/**
 * 用于表示数据结果集的数据表，类似于ResultSet，
 * 并存储了数据集的元数据，实现了数据集的分页功能
 * @author XiaoRuxing
 * @create 2:25:04 PM
 * @version 1.0
 */
public class SqlResult implements Serializable,Result{

	private static final long serialVersionUID = -66923606074266477L;//类序列号	
	private int iRows; //记录集实际行数
	private int iCols;//记录集实际列数
	@SuppressWarnings("unused")
	private int iPageRow; //分页单页记录行数
	@SuppressWarnings({ "unused", "unused" })
	private int iMaxSingleRow; //单页最大记录行数
	private D2Array<String> d2ResultSet; //用户存储记录集的table
	private D2Array<String> recyleResultSet; //用户存储要删除的记录
	@SuppressWarnings("unused")
	private DbResource dbResource;//数据源信息
	private SqlResultMetaData metadata; //记录集的metadata
	@SuppressWarnings("unused")
	private String sPageID;//数据集对应页ID
	@SuppressWarnings("unused")
	private RowID  ridFistRow;	//首行RowID
	@SuppressWarnings("unused")
	private RowID	 ridLastRow;	//最后一行RowID
	public static final int  SINGLE_PAGE=1;//单页模式
	public static final int  MULTI_PAGE=2;//多页模式
	private int iQueryModel;//查询模式
	/** 默认显示条数*/
	private int defaultLine = 500;

	/** 当前获取的记录行数 */
	private int iCurrentRow;

	/**
	 * 	构造函数
	 * @param iQueryModel 分页模式
	 */
	public SqlResult(int iQueryModel){
		this.iQueryModel = iQueryModel ; 
		this.iCurrentRow = -1;
	}
	/**
	 * 构造函数
	 * @param iQueryModel	分页模式
	 * @param sUserId		用户ID
	 * @param sPageId		页面ID
	 */
	public SqlResult(int iQueryModel,String sUserId,String sPageId){
		this(iQueryModel);
	}

	/**
	 * 获取系统参数
	 * @param sUserId 用户ID
	 * @param sPageId 页面ID
	 */
	//TODO 获取系统参数，需要等获取系统参数服务开发完后完善
	@SuppressWarnings({ "unused", "unchecked" })
	private void getSystemProperty(String sUserId,String sPageId){
		KvMap kvmSystemProperties;
		//通过KvMap批量查询系统参数，如果返回参数为空则抛出4级异常  

		//设置分页记录行数
		//设置非分页单页最大记录行数
	}


	/**
	 * 存储数据集
	 * @param rs	数据集
	 * @throws ErrorMessage 
	 */
	public void put(ResultSet rs) throws ErrorMessage
	{
		if(iQueryModel==1){
			/** 单页模式操作 */
			putSingle(rs);
		}
		else{
			/** 多页模式操作 */
			putMulti(rs);
		}
	}
	
	/**
	 * 存储数据集
	 * @param rs	数据集
	 * @param resultSize 数据集的大小
	 * @throws ErrorMessage 
	 */
	public void put(ResultSet rs,int resultSize) throws ErrorMessage
	{
		if(iQueryModel==1){
			/** 单页模式操作 */
			putSingle(rs,resultSize);
		}
		else{
			/** 多页模式操作 */
			putMulti(rs);
		}
	}
	
	/**
	 * 存储数据集（分页）
	 * @param rs	数据集
	 * @param strat 开始位置
	 * @param end   结束位置
	 * @throws ErrorMessage 
	 */
	public void put(ResultSet rs,int strat,int end) throws ErrorMessage{
		try {
			/** 保存元数据信息 */
			this.metadata=new SqlResultMetaData(rs.getMetaData());
			/** 设置列数 */
			this.iCols=metadata.getColumnCount();
			/** 封装数据，设置行数 */
			this.iRows=setSqlResult(rs,strat,end);
		}catch(ErrorMessage e){
			throw e;
		}catch (Exception e) {
			throw new ErrorMessage(e);
		}
	}

	/**
	 * 单页模式插入数据集
	 * @param rs
	 */
	public void putSingle(ResultSet rs) throws ErrorMessage{
		putSingle(rs,defaultLine);
	}
	
	/**
	 * 单页模式插入数据集
	 * @param rs
	 * @param resultSize 数据集的大小
	 */
	public void putSingle(ResultSet rs,int resultSize) throws ErrorMessage{

		try {
			/** 保存元数据信息 */
			this.metadata=new SqlResultMetaData(rs.getMetaData());
			/** 设置列数 */
			this.iCols=metadata.getColumnCount();
			/** 封装数据，设置行数 */
			this.iRows=setSqlResult(rs,resultSize);
		}catch(ErrorMessage e){
			throw e;
		}catch (Exception e) {
			throw new ErrorMessage(e);
		}
	}

	/**
	 * 分页模式插入数据集
	 * @param rs
	 */
	//TODO 多页模式的插入数据，需要等SqlResultPool接口确定后编写
	public void putMulti(ResultSet rs) throws ErrorMessage{
		throw new ErrorMessage("尚未实现多页模式的插入数据");
	}

	/**
	 * 将rs封装到D2Array
	 * @param rs 数据集
	 * @return	int
	 * @throws ErrorMessage SQL异常
	 */
	public int setSqlResult(ResultSet rs) throws ErrorMessage{

		/** 记录行数 */
		int iRowNumber=0;
		StringBuilder columnOptFlag = null;
		try {
			this.d2ResultSet=new D2Array<String>(iCols+2);
			this.recyleResultSet = new D2Array<String>(iCols+2);
			while(rs.next()){ 
				String [] str=new String[iCols+2];
				columnOptFlag = new StringBuilder();
				int i = 1;
				/** 数组插入从下标为0开始，使得列下标从0开始 */
				for(i=1;i<=iCols;i++){
					str[i-1]=rs.getString(i);
					columnOptFlag.append(Sql_Result_Column_Opt_Flag.NOTHING.toString());
				}
				str[i-1] = Sql_Result_Row_Opt_Flag.NOTHING.toString();
				str[i] = columnOptFlag.toString();
				/** 放入一行 */
				d2ResultSet.put(str);

				/** 设置行计数器 */
				iRowNumber++;
			}
		}catch (Exception e) {
			throw new ErrorMessage(e);
		}
		return iRowNumber;
	}
	
	/**
	 * 将rs封装到D2Array
	 * @param rs 数据集
	 * @return
	 * @throws ErrorMessage SQL异常
	 */
	public int setSqlResult(ResultSet rs,int resultSize) throws ErrorMessage{

		/** 记录行数 */
		int iRowNumber=0;
		StringBuilder columnOptFlag = null;
		try {
			this.d2ResultSet=new D2Array<String>(iCols+2);
			this.recyleResultSet = new D2Array<String>(iCols+2);
			while(rs.next() && iRowNumber<resultSize){ 
				String [] str=new String[iCols+2];
				columnOptFlag = new StringBuilder();
				int i = 1;
				/** 数组插入从下标为0开始，使得列下标从0开始 */
				for(i=1;i<=iCols;i++){
					str[i-1]=rs.getString(i);
					columnOptFlag.append(Sql_Result_Column_Opt_Flag.NOTHING.toString());
				}
				str[i-1] = Sql_Result_Row_Opt_Flag.NOTHING.toString();
				str[i] = columnOptFlag.toString();
				/** 放入一行 */
				d2ResultSet.put(str);
				
				/** 设置行计数器 */
				iRowNumber++;
			}
		}catch (Exception e) {
			throw new ErrorMessage(e);
		}
		return iRowNumber;
	}
	
	/**
	 * 将rs封装到D2Array
	 * @param rs 数据集
	 * @return
	 * @throws ErrorMessage SQL异常
	 */
	public int setSqlResult(ResultSet rs,int start,int end) throws ErrorMessage{
		/** 记录行数 */
		int rsNum = 0;
		int iRowNumber=start-1;
		StringBuilder columnOptFlag = null;
		try {
			this.d2ResultSet=new D2Array<String>(iCols+2);
			this.recyleResultSet = new D2Array<String>(iCols+2);
			while(rs.next()){
				if(start-1>0 && start-1>=iRowNumber){
					rs.absolute(start);
				}
				String [] str=new String[iCols+2];
				columnOptFlag = new StringBuilder();
				int i=1;
				if(iRowNumber<end){
					/** 数组插入从下标为0开始，使得列下标从0开始 */
					for(i=1;i<=iCols;i++){
						str[i-1]=rs.getString(i);
						columnOptFlag.append(Sql_Result_Column_Opt_Flag.NOTHING.toString());
					}
					str[i-1] = Sql_Result_Row_Opt_Flag.NOTHING.toString();
					str[i] = columnOptFlag.toString();
					/** 放入一行 */
					d2ResultSet.put(str);
					
					/** 设置行计数器 */
					iRowNumber++;
					rsNum++;
				}else{
					break;
				}
			}
		}catch (Exception e) {
			throw new ErrorMessage(e);
		}
		return rsNum;
	}

	/**
	 * 	跳转到下一页记录集
	 * @return 下一页记录集
	 */
	//TODO 需要等SqlResultPool接口确定后编写
	public SqlResult  nextPage(){
		return null;
	}

	/**
	 * 	跳转到前一页记录集
	 * @return 前一页记录集
	 */
	//TODO 需要等SqlResultPool接口确定后编写
	public SqlResult  prePage(){
		return null;
	}
	/**
	 * 	跳转到第一页
	 * @return 第一页记录集
	 */
	//TODO 需要等SqlResultPool接口确定后编写
	public SqlResult  firstPage(){
		return null;
	}

	/**
	 * 	跳转到下一页
	 * @return 下一页记录集
	 */
	//TODO 需要等SqlResultPool接口确定后编写
	public SqlResult  lastPage(){
		return null;
	}

	/**
	 * 	跳转到指定页
	 * @return 指定页记录集
	 */
	//TODO 需要等SqlResultPool接口确定后编写
	public SqlResult  goToPage(){
		return null;
	}

	/**
	 * 	返回分页模式
	 * @return	分页模式
	 */
	//TODO 需要等SqlResultPool接口确定后编写
	public int getQueryModel(){
		return iQueryModel;
	}

	/**
	 * 	返回记录集行数
	 * @return 记录集行数
	 */
	//TODO 需要等SqlResultPool接口确定后编写
	public int size(){
		return iRows;
	}

	/**
	 * 记录集列数
	 * @return 
	 */
	public int getColCount(){
		return iCols;
	}

	/**
	 * 返回所有行
	 * @return
	 */
	public D2Array<String> get(){
		return d2ResultSet;
	}

	/**
	 * 获取记录的二维数组表示形式
	 * @return 记录的二维数组表示形式
	 * @throws ErrorMessage 
	 */
	public String[][] getArray() throws ErrorMessage{
		String[][] str=new String[size()][];
		for(int i=0;i<size();i++){
			str[i]=d2ResultSet.get(i);
		}
		return str;
	}

	/**
	 * 	返回指定行
	 * @param iRowNumber	行号 第一行下标为0
	 * @return	指定行
	 * @deprecated 已过时
	 * @throws ErrorMessage 
	 */
	public String[] get(int iRowIndex) throws ErrorMessage{
		return  d2ResultSet.get(iRowIndex);
	}

	/**
	 * 	根据行号和列序号返回指定字段的值,第一行下标为0，第一列下标为0 已过时,getString()取代
	 * @param iRowNumber	行号
	 * @param iColNumber	列序号
	 * @return	指定字段值
	 * @throws ErrorMessage 
	 */
	public String get(int iRowIndex,int iColIndex) throws ErrorMessage{
		return d2ResultSet.get(iRowIndex, iColIndex);
	}

	/**
	 * 	根据行号和字段名，返回指定字段的值，第一行下标为0，第一列下标为0<BR>
	 * (已过时,getString()取代)
	 * @param iRowNumber  行号
	 * @param sColumnName 字段名
	 * @return 指定字段值
	 * @throws ErrorMessage 
	 */
	public String get(int iRowIndex,String  sColumnName) throws ErrorMessage{
		return d2ResultSet.get(iRowIndex,getColumnOrder(sColumnName));
	}

	/**
	 * 	返回指定列名序号
	 * @param sColumnName	列名
	 * @return	指定列序号
	 * @throws ErrorMessage 
	 */
	public int getColumnOrder(String sColumnName) throws ErrorMessage{
		int colOrder = metadata.getColumnIndexByName(sColumnName);
		if(colOrder<0){
			throw new ErrorMessage("Column "+sColumnName+" not exist in the result!");
		}
		return colOrder;
	}

	/**
	 * 	返回指定列名称
	 * @param iColumnIndex	列序号，第一列下标为0
	 * @return	指定列名称
	 */
	public String getColumnName(int iColumnIndex){
		return metadata.getColumnNameByIndex(iColumnIndex);
	}

	/**
	 * 	返回指定列数据类型
	 * @param sColumnName 列名
	 * @return	指定列数据类型
	 */
	public String getColumnTypeByName(String sColumnName){
		return metadata.getColumnTypeByName(sColumnName);
	}

	/**
	 * 	返回指定列数据类型
	 * @param iColumnIndex 列序号 第一列下标为0
	 * @return	指定列数据类型
	 */
	public String getColumnTypeByIndex(int iColumnIndex){
		return metadata.getColumnTypeByIndex(iColumnIndex);
	}

	/**
	 * 返回是否为空
	 * @return
	 */
	public boolean isNull(){
		return this.iRows==0;
	}

	/**
	 * 在当前结果集尾部插入结果集
	 * @param result
	 * @throws ErrorMessage 
	 */
	public void concat(SqlResult result) throws ErrorMessage{

		/** 如果结果集列数不一致抛出异常 */
		if(result.getColCount()!=getColCount()){
			throw new ErrorMessage("下标越界");
		}
		if(result==null)return;
		this.d2ResultSet.put(result.get());//将传入记录放入当前记录集尾部
		this.iRows = this.iRows+result.size();//设置合并后记录集行数
	}

	/**
	 * 获取当前行中指定列的值，列下标从0开始 
	 * @param iColIndex 列下标
	 * @return 指定列的值
	 * @throws ErrorMessage
	 */
	public String getString(int iColIndex) throws ErrorMessage{
		return this.get(this.iCurrentRow, iColIndex);
	}

	/**
	 * 获取当前行中指定列的值 
	 * @param sColumnName 列名
	 * @return 指定列的值
	 * @throws ErrorMessage
	 */
	public String getString(String sColumnName) throws ErrorMessage{
		return this.get(this.iCurrentRow, sColumnName);
	}

	/**
	 * 获取当前行中指定列的整数值，列下标从0开始 
	 * @param iColumnIndex 列下标
	 * @return 指定列的值
	 * @throws ErrorMessage
	 */
	public int getInt(int iColumnIndex) throws ErrorMessage{
		return TOOLS.stringToInt(this.get(this.iCurrentRow, iColumnIndex));
	}

	/**
	 * 获取当前行中指定列的整数值 
	 * @param sColumnName 列名
	 * @return 指定列的值
	 * @throws ErrorMessage 
	 */
	public int getInt(String sColumnName) throws ErrorMessage{
		return TOOLS.stringToInt(this.get(this.iCurrentRow, sColumnName));
	}

	/**
	 * 获取当前行中指定列的布尔值  如果值为"0"返回false  如果值为"1"返回true 不在范围内抛出异常
	 * @param iColumnIndex 列下标
	 * @return 当前行中指定列的布尔值
	 * @throws ErrorMessage
	 */
	public boolean getBoolean(int iColumnIndex) throws ErrorMessage{
		return this.getBoolean(this.iCurrentRow, iColumnIndex);
	}

	/**
	 * 获取当前行中指定列的布尔值  如果值为"0"返回false  如果值为"1"返回true 不在范围内抛出异常
	 * @param sColumnName 列下标
	 * @return 当前行中指定列的布尔值
	 * @throws ErrorMessage
	 */
	public boolean getBoolean(String sColumnName) throws ErrorMessage{
		return this.getBoolean(this.getColumnOrder(sColumnName));
	}
	
	/**
	 * 获取当前行中指定列的布尔值  如果值为"0"返回false  如果值为"1"返回true 不在范围内抛出异常
	 * @param sColumnName 列下标
	 * @return 当前行中指定列的布尔值
	 * @throws ErrorMessage
	 */
	public boolean getBoolean(int iRowIndex, String sColumnName) throws ErrorMessage{
		return this.getBoolean(iRowIndex, this.getColumnOrder(sColumnName));
	}
	
	/**
	 * 获取当前行中指定列的布尔值  如果值为"0"返回false  如果值为"1"返回true 不在范围内抛出异常
	 * @param sColumnName 列下标
	 * @return 当前行中指定列的布尔值
	 * @throws ErrorMessage
	 */
	public boolean getBoolean(int iRowIndex, int iColumnIndex) throws ErrorMessage{
		String colValue=this.get(iRowIndex, iColumnIndex);
		if(colValue==null || "".equals(colValue)){
			return false;
		}
		if("0".equals(colValue) || "N".equals(colValue.toUpperCase())){
			return false;
		}else if("1".equals(colValue) || "Y".equals(colValue.toUpperCase())){
			return true;
		}else{
			return false;
		}
	}

	/**
	 * 将光标从当前位置向前移一行
	 * @return 如果存在下一行则返回 true；如果不存在下一行则返回 false  
	 */
	public boolean next(){
		if(this.iCurrentRow>=this.size()-1){
			return false;
		}else{
			this.iCurrentRow++;
			return true;
		}
	}

	/**
	 * 将光标从当前位置向上一行 
	 * @return 如果存在上一行返回true;如果不存在上一行返回false
	 */
	public boolean previous(){
		if(this.iCurrentRow<=0){
			return false;
		}else{
			this.iCurrentRow--;
			return true;
		}
	}

	/**
	 * 将光标移动到第一行
	 * @return 如果记录集为空返回false,否则返回真
	 */
	public boolean first(){
		if(this.isNull()){
			return false;
		}else{
			this.iCurrentRow=0;
			return true;
		}
	}

	/**
	 * 将光标移动到最后一行 
	 * @return 如果记录集为空返回false,否则返回真
	 */
	public boolean last(){
		if(this.isNull()){
			return false;
		}else{
			this.iCurrentRow=this.size()-1;
			return false;
		}
	}

	/**
	 * 将光标移动到指定行
	 * @param row 行下标 从0开始
	 * @return 如果存在指定下标行返回true,否则返回false
	 */
	public boolean absolute(int row){
		if(row>this.size()-1||row<0){
			return false;
		}else{
			this.iCurrentRow=row;
			return true;
		}
	}

	/**
	 * 获取当前访问行编号 
	 * @return 当前访问行编号,如果不存在返回-1
	 */
	public int getCurrentRow(){
		return this.iCurrentRow;
	}

	/**
	 * 返回字符串表示形式
	 * @return
	 */
	public String toString(){
		return d2ResultSet.toString();
	}
	
	/**
	 * 将光标移动到最后一行之后
	 */
	public void afterLast() {
		this.iCurrentRow=this.size();
	}
	
	/**
	 * 将光标移动到第一行之前
	 */
	public void beforeFirst() {
		this.iCurrentRow=-1;
	}
	
	/**
	 * 更新当前记录行的指定列
	 * @param sColumnName 列名
	 * @param sColumnData 列数据
	 * @return            是否更新成功
	 * @throws ErrorMessage 
	 */
	public boolean update(String sColumnName,String sColumnData) throws ErrorMessage{
		if(this.iCurrentRow<0){
			return false;
		}else{
			int updateCol = -1;
			String[] rowData = d2ResultSet.get(this.iCurrentRow);
			updateCol = this.metadata.getColumnIndexByName(sColumnName);
			rowData[updateCol] = sColumnData;
			d2ResultSet.set(this.iCurrentRow, rowData);
			return true;
		}
	}
	
	/**
	 * 更新数据集
	 * @param updateData 更新数据     
	 * @param updateCondition 更新条件
	 * @return
	 * @throws ErrorMessage 
	 */
	public boolean update(DataFilter updateData,DataFilter updateCondition) throws ErrorMessage{
		char[] columnFlag = null;
		for(int i=0;i<this.size();i++){
			if(searchRow(i, updateCondition)){
				String[] rowData = d2ResultSet.get(i);//查找到符合条件行
				columnFlag = rowData[this.getColCount()+1].toCharArray();//字段更新标志字段
				String fieldName = null;
				String fieldValue = null;
				int updateCol = -1;
				for(Map.Entry<String, String> map:updateData.getFilter()){//更新符合条件行数据
					fieldName = map.getKey();
					fieldValue = map.getValue();
					updateCol = this.metadata.getColumnIndexByName(fieldName);
					if(updateCol==-1){//如果字段名不存在，忽略字段
						continue;
					}
					rowData[updateCol] = fieldValue;
					columnFlag[updateCol] = '1';
				}
				rowData[this.getColCount()] = Sql_Result_Row_Opt_Flag.UPDATE.toString();
				rowData[this.getColCount()+1] = TOOLS.charArrayTOString(columnFlag);
				d2ResultSet.set(i, rowData);
			}
		}
		return true;
	}
	
	/**
	 * 添加一条记录到数据集
	 * @param insertData 要添加的记录
	 * @return
	 * @throws ErrorMessage
	 */
	public boolean insert(DataFilter insertData) throws ErrorMessage{
		String fieldName = null;
		String fieldValue = null;
		String[] colData = new String[this.getColCount()+2];
		int updateCol = -1;
		for(Map.Entry<String, String> map:insertData.getFilter()){//更新符合条件行数据
			fieldName = map.getKey();
			fieldValue = map.getValue();
			updateCol = this.getColumnOrder(fieldName);
			colData[updateCol] = fieldValue;
		}
		colData[this.getColCount()] = Sql_Result_Row_Opt_Flag.INSERT.toString();
		colData[this.getColCount()+1] = TOOLS.getZeroArray(this.getColCount());
		d2ResultSet.put(colData);
		this.iRows++;
		return true;
	}
	
	/**
	 * 删除一条记录
	 * @param deleteCondition 删除条件
	 * @return
	 * @throws ErrorMessage
	 */
	public boolean delete(DataFilter deleteCondition) throws ErrorMessage{
		for(int i=0;i<this.size();i++){
			if(searchRow(i, deleteCondition)){
				String[] rowData = d2ResultSet.get(i);//查找到符合条件行
				rowData[this.getColCount()] = Sql_Result_Row_Opt_Flag.DELETE.toString();
				this.recyleResultSet.put(rowData);
				d2ResultSet.remove(i);
				this.iRows--;
			}
		}
		return true;
	}
	
	/**
	 * 根据过滤条件查找行
	 * @param filter 过滤条件
	 * @return
	 * @throws ErrorMessage
	 */
	public int search(DataFilter filter) throws ErrorMessage{
		for(int i=0;i<this.size();i++){
			if(searchRow(i, filter)){
				return i;
			}
		}
		return -1;
	}
	
	/**
	 * 查询行是否满足查询条件
	 * @param row 行下标
	 * @param filter 查询条件键值对(字段名、字段值)，可以有多个
	 * @return 如果行数据满足过滤条件返回true
	 * @throws ErrorMessage 如果过滤条件中的字段在数据集中不存在抛出异常
	 */
	public boolean searchRow(int row,DataFilter filter) throws ErrorMessage{
		boolean matchFilter = true;
		String fieldName = null;
		String fieldValue = null;
		for(Map.Entry<String, String> map:filter.getFilter()){
			fieldName = map.getKey();
			fieldValue = map.getValue();
			if(fieldValue == null && this.get(row, fieldName)==null){//如果过滤字段值为空，数据集对应字段的值为空跳过当前条件
				continue;
			}else if(fieldValue == null && this.get(row, fieldName)!=null){//如果过滤字段值为空，数据集对应字段的值不为空返回false
				return false;
			}else if(!fieldValue.equals(this.get(row, fieldName))){//如果过滤字段值不等于数据集对应字段的值返回false
				return false;
			}
		}
		return matchFilter;
	}
	
	/**
	 * 获取当前行状态是否为更新
	 * @return
	 * @throws ErrorMessage 
	 */
	public boolean isUpdate() throws ErrorMessage{
		String updateFlag = this.get(this.iCurrentRow, this.iCols);
		if(Sql_Result_Row_Opt_Flag.UPDATE.toString().equals(updateFlag)||
				Sql_Result_Row_Opt_Flag.INSERT.toString().equals(updateFlag)){
			return true;
		}else{
			return false;
		}
	}
	
	/**
	 * 获取更新当前数据集记录的数据对象
	 * @return
	 * @throws ErrorMessage
	 */
	public DataFilter getUpdateFilter() throws ErrorMessage{
		DataFilter filter = new DataFilter();
		for(int i = 0 ;i<this.getColCount();i++){
			filter.put(this.metadata.getColumnNameByIndex(i), 
					this.getString(i));
		}
		return filter;
	}
	
	/**
	 * 获取要删除记录
	 * @param row 行下标
	 * @param sColumnName 条件字段名称
	 * @return
	 * @throws ErrorMessage
	 */
	public String getDeleteColumn(int row,String sColumnName) throws ErrorMessage{
		if(this.recyleResultSet!=null){
			return this.recyleResultSet.get(row, this.getColumnOrder(sColumnName));
		}else{
			return null;
		}
	}
	
	/**
	 * 获取要删除记录数
	 * @return
	 */
	public int getDeleteNumb(){
		if(this.recyleResultSet!=null){
			return this.recyleResultSet.getRowNumber();
		}else{
			return 0;
		}
	}
	
	/**
	 * 获取元数据
	 * @return
	 */
	public SqlResultMetaData getMetadata(){
		return metadata;
	}
	
	/**
	 * 返回存在字段
	 * @param columnName  字段名称
	 * @return
	 * @throws ErrorMessage
	 */
	public boolean existColumn(String columnName) throws ErrorMessage {
		int colOrder = metadata.getColumnIndexByName(columnName);
		if(colOrder<0)
		{
			return false;
		}else{
			return true;
		}
	}
}
